Générateur de Clés et Chiffrement Asymétrique RSA 🔐

Ce projet permet de générer des paires de clés RSA et de chiffrer ou déchiffrer des messages en utilisant le chiffrement asymétrique RSA. Il est destiné aux passionnés de cryptographie et aux développeurs qui souhaitent expérimenter avec le chiffrement sécurisé.

Fonctionnement du Générateur RSA :

RSA est un algorithme de chiffrement asymétrique qui utilise une paire de clés (publique et privée). La clé publique est utilisée pour chiffrer un message, tandis que la clé privée est nécessaire pour le déchiffrer. Ce projet implémente la génération des clés et leur utilisation pour chiffrer ou déchiffrer des données sensibles.

Script Python de Génération de Clés RSA et Chiffrement :

from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_OAEP
from Crypto.Random import get_random_bytes
from Crypto.Signature import pkcs1_15
from Crypto.Hash import SHA256
import base64

# Fonction pour générer une paire de clés RSA
def generate_rsa_keys():
    key = RSA.generate(2048)
    private_key = key.export_key(passphrase="votre_phrase_de_passe", pkcs=8, protection="scryptAndAES128-CBC")
    public_key = key.publickey().export_key()

    with open("private.pem", "wb") as priv_file:
        priv_file.write(private_key)

    with open("public.pem", "wb") as pub_file:
        pub_file.write(public_key)

    print("Clés RSA générées et sauvegardées dans des fichiers.")

# Fonction pour chiffrer un message avec la clé publique
def encrypt_message(message, public_key_file="public.pem"):
    try:
        with open(public_key_file, "rb") as pub_file:
            public_key = RSA.import_key(pub_file.read())
        cipher = PKCS1_OAEP.new(public_key)
        encrypted_message = cipher.encrypt(message.encode())
        return base64.b64encode(encrypted_message).decode()
    except Exception as e:
        print(f"Erreur de chiffrement : {e}")

# Fonction pour déchiffrer un message avec la clé privée
def decrypt_message(encrypted_message, private_key_file="private.pem"):
    try:
        with open(private_key_file, "rb") as priv_file:
            private_key = RSA.import_key(priv_file.read(), passphrase="votre_phrase_de_passe")
        cipher = PKCS1_OAEP.new(private_key)
        decrypted_message = cipher.decrypt(base64.b64decode(encrypted_message.encode()))
        return decrypted_message.decode()
    except Exception as e:
        print(f"Erreur de déchiffrement : {e}")

# Fonction pour signer un message
def sign_message(message, private_key_file="private.pem"):
    try:
        with open(private_key_file, "rb") as priv_file:
            private_key = RSA.import_key(priv_file.read(), passphrase="votre_phrase_de_passe")
        h = SHA256.new(message.encode())
        signature = pkcs1_15.new(private_key).sign(h)
        return base64.b64encode(signature).decode()
    except Exception as e:
        print(f"Erreur de signature : {e}")

# Fonction pour vérifier une signature
def verify_signature(message, signature, public_key_file="public.pem"):
    try:
        with open(public_key_file, "rb") as pub_file:
            public_key = RSA.import_key(pub_file.read())
        h = SHA256.new(message.encode())
        pkcs1_15.new(public_key).verify(h, base64.b64decode(signature.encode()))
        print("Signature valide.")
    except (ValueError, TypeError):
        print("Signature invalide.")
    except Exception as e:
        print(f"Erreur de vérification : {e}")

if __name__ == "__main__":
    print("Générateur de Clés RSA et Chiffrement")

    # Génération des clés
    generate_rsa_keys()

    # Message à chiffrer
    message = input("Entrez le message à chiffrer : ")

    # Chiffrement du message
    encrypted_message = encrypt_message(message)
    print(f"Message chiffré : {encrypted_message}")

    # Déchiffrement du message
    decrypted_message = decrypt_message(encrypted_message)
    print(f"Message déchiffré : {decrypted_message}")

    # Signature du message
    signature = sign_message(message)
    print(f"Signature : {signature}")

    # Vérification de la signature
    verify_signature(message, signature)

        

Fonctionnalités Principales :

• 🔑 Génération de Clés RSA : Génère une paire de clés RSA de 2048 bits et les sauvegarde dans des fichiers sécurisés.
• 🔐 Chiffrement de Messages : Permet de chiffrer un message en utilisant la clé publique RSA.
• 🔓 Déchiffrement de Messages : Permet de déchiffrer un message en utilisant la clé privée RSA.
• ✍️ Signature Numérique : Ajoute la possibilité de signer un message et de vérifier la signature avec les clés RSA.

Comment Utiliser l'Outil ?

1. Installez les bibliothèques nécessaires avec la commande suivante :

pip install pycryptodome

2. Exécutez le script Python pour générer les clés RSA et chiffrer un message :

python generateur_rsa.py

3. Suivez les instructions pour entrer un message, observer le chiffrement/déchiffrement, et tester les signatures numériques.

Prévention et Sécurité :

• Conservez vos clés privées en lieu sûr.
• Utilisez une phrase de passe pour les clés privées.
• Renouvelez vos clés périodiquement.